home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / include / regexp.h < prev    next >
C/C++ Source or Header  |  2009-10-07  |  7KB  |  229 lines
  1. /* Copyright (C) 1996, 1997, 1998, 1999, 2004, 2008
  2.    Free Software Foundation, Inc.
  3.    This file is part of the GNU C Library.
  4.    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
  5.  
  6.    The GNU C Library is free software; you can redistribute it and/or
  7.    modify it under the terms of the GNU Lesser General Public
  8.    License as published by the Free Software Foundation; either
  9.    version 2.1 of the License, or (at your option) any later version.
  10.  
  11.    The GNU C Library is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.    Lesser General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU Lesser General Public
  17.    License along with the GNU C Library; if not, write to the Free
  18.    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19.    02111-1307 USA.  */
  20.  
  21. #ifndef _REGEXP_H
  22. #define _REGEXP_H    1
  23.  
  24. /* The contents of this header file was first standardized in X/Open
  25.    System Interface and Headers Issue 2, originally coming from SysV.
  26.    In issue 4, version 2, it is marked as TO BE WITDRAWN, and it has
  27.    been withdrawn in SUSv3.
  28.  
  29.    This code shouldn't be used in any newly written code.  It is
  30.    included only for compatibility reasons.  Use the POSIX definition
  31.    in <regex.h> for portable applications and a reasonable interface.  */
  32.  
  33. #include <features.h>
  34. #include <alloca.h>
  35. #include <regex.h>
  36. #include <stdlib.h>
  37. #include <string.h>
  38.  
  39. /* The implementation provided here emulates the needed functionality
  40.    by mapping to the POSIX regular expression matcher.  The interface
  41.    for the here included function is weird (this really is a harmless
  42.    word).
  43.  
  44.    The user has to provide six macros before this header file can be
  45.    included:
  46.  
  47.    INIT        Declarations vor variables which can be used by the
  48.         other macros.
  49.  
  50.    GETC()    Return the value of the next character in the regular
  51.         expression pattern.  Successive calls should return
  52.         successive characters.
  53.  
  54.    PEEKC()    Return the value of the next character in the regular
  55.         expression pattern.  Immediately successive calls to
  56.         PEEKC() should return the same character which should
  57.         also be the next character returned by GETC().
  58.  
  59.    UNGETC(c)    Cause `c' to be returned by the next call to GETC() and
  60.         PEEKC().
  61.  
  62.    RETURN(ptr)    Used for normal exit of the `compile' function.  `ptr'
  63.         is a pointer to the character after the last character of
  64.         the compiled regular expression.
  65.  
  66.    ERROR(val)    Used for abnormal return from `compile'.  `val' is the
  67.         error number.  The error codes are:
  68.         11    Range endpoint too large.
  69.         16    Bad number.
  70.         25    \digit out of range.
  71.         36    Illegal or missing delimiter.
  72.         41    No remembered search string.
  73.         42    \( \) imbalance.
  74.         43    Too many \(.
  75.         44    More tan two numbers given in \{ \}.
  76.         45    } expected after \.
  77.         46    First number exceeds second in \{ \}.
  78.         49    [ ] imbalance.
  79.         50    Regular expression overflow.
  80.  
  81.   */
  82.  
  83. __BEGIN_DECLS
  84.  
  85. /* Interface variables.  They contain the results of the successful
  86.    calls to `setp' and `advance'.  */
  87. extern char *loc1;
  88. extern char *loc2;
  89.  
  90. /* The use of this variable in the `advance' function is not
  91.    supported.  */
  92. extern char *locs;
  93.  
  94.  
  95. #ifndef __DO_NOT_DEFINE_COMPILE
  96. /* Get and compile the user supplied pattern up to end of line or
  97.    string or until EOF is seen, whatever happens first.  The result is
  98.    placed in the buffer starting at EXPBUF and delimited by ENDBUF.
  99.  
  100.    This function cannot be defined in the libc itself since it depends
  101.    on the macros.  */
  102. char *
  103. compile (char *__restrict instring, char *__restrict expbuf,
  104.      __const char *__restrict endbuf, int eof)
  105. {
  106.   char *__input_buffer = NULL;
  107.   size_t __input_size = 0;
  108.   size_t __current_size = 0;
  109.   int __ch;
  110.   int __error;
  111.   INIT
  112.  
  113.   /* Align the expression buffer according to the needs for an object
  114.      of type `regex_t'.  Then check for minimum size of the buffer for
  115.      the compiled regular expression.  */
  116.   regex_t *__expr_ptr;
  117. # if defined __GNUC__ && __GNUC__ >= 2
  118.   const size_t __req = __alignof__ (regex_t *);
  119. # else
  120.   /* How shall we find out?  We simply guess it and can change it is
  121.      this really proofs to be wrong.  */
  122.   const size_t __req = 8;
  123. # endif
  124.   expbuf += __req;
  125.   expbuf -= (expbuf - ((char *) 0)) % __req;
  126.   if (endbuf < expbuf + sizeof (regex_t))
  127.     {
  128.       ERROR (50);
  129.     }
  130.   __expr_ptr = (regex_t *) expbuf;
  131.   /* The remaining space in the buffer can be used for the compiled
  132.      pattern.  */
  133.   __expr_ptr->__REPB_PREFIX (buffer) = expbuf + sizeof (regex_t);
  134.   __expr_ptr->__REPB_PREFIX (allocated)
  135.     = endbuf - (char *) __expr_ptr->__REPB_PREFIX (buffer);
  136.  
  137.   while ((__ch = (GETC ())) != eof)
  138.     {
  139.       if (__ch == '\0' || __ch == '\n')
  140.     {
  141.       UNGETC (__ch);
  142.       break;
  143.     }
  144.  
  145.       if (__current_size + 1 >= __input_size)
  146.     {
  147.       size_t __new_size = __input_size ? 2 * __input_size : 128;
  148.       char *__new_room = (char *) alloca (__new_size);
  149.       /* See whether we can use the old buffer.  */
  150.       if (__new_room + __new_size == __input_buffer)
  151.         {
  152.           __input_size += __new_size;
  153.           __input_buffer = (char *) memcpy (__new_room, __input_buffer,
  154.                            __current_size);
  155.         }
  156.       else if (__input_buffer + __input_size == __new_room)
  157.         __input_size += __new_size;
  158.       else
  159.         {
  160.           __input_size = __new_size;
  161.           __input_buffer = (char *) memcpy (__new_room, __input_buffer,
  162.                         __current_size);
  163.         }
  164.     }
  165.       __input_buffer[__current_size++] = __ch;
  166.     }
  167.   if (__current_size)
  168.     __input_buffer[__current_size++] = '\0';
  169.   else
  170.     __input_buffer = "";
  171.  
  172.   /* Now compile the pattern.  */
  173.   __error = regcomp (__expr_ptr, __input_buffer, REG_NEWLINE);
  174.   if (__error != 0)
  175.     /* Oh well, we have to translate POSIX error codes.  */
  176.     switch (__error)
  177.       {
  178.       case REG_BADPAT:
  179.       case REG_ECOLLATE:
  180.       case REG_ECTYPE:
  181.       case REG_EESCAPE:
  182.       case REG_BADRPT:
  183.       case REG_EEND:
  184.       case REG_ERPAREN:
  185.       default:
  186.     /* There is no matching error code.  */
  187.     RETURN (36);
  188.       case REG_ESUBREG:
  189.     RETURN (25);
  190.       case REG_EBRACK:
  191.     RETURN (49);
  192.       case REG_EPAREN:
  193.     RETURN (42);
  194.       case REG_EBRACE:
  195.     RETURN (44);
  196.       case REG_BADBR:
  197.     RETURN (46);
  198.       case REG_ERANGE:
  199.     RETURN (11);
  200.       case REG_ESPACE:
  201.       case REG_ESIZE:
  202.     ERROR (50);
  203.       }
  204.  
  205.   /* Everything is ok.  */
  206.   RETURN ((char *) (__expr_ptr->__REPB_PREFIX (buffer)
  207.             + __expr_ptr->__REPB_PREFIX (used)));
  208. }
  209. #endif
  210.  
  211.  
  212. /* Find the next match in STRING.  The compiled regular expression is
  213.    found in the buffer starting at EXPBUF.  `loc1' will return the
  214.    first character matched and `loc2' points to the next unmatched
  215.    character.  */
  216. extern int step (__const char *__restrict __string,
  217.          __const char *__restrict __expbuf) __THROW;
  218.  
  219. /* Match the beginning of STRING with the compiled regular expression
  220.    in EXPBUF.  If the match is successful `loc2' will contain the
  221.    position of the first unmatched character.  */
  222. extern int advance (__const char *__restrict __string,
  223.             __const char *__restrict __expbuf) __THROW;
  224.  
  225.  
  226. __END_DECLS
  227.  
  228. #endif /* regexp.h */
  229.